home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / DEMON / RISCOS2 / TCP_131S.ARC / c / fingserv < prev    next >
Text File  |  1993-12-22  |  7KB  |  224 lines
  1. /*
  2.  *
  3.  *      Finger support...
  4.  *
  5.  *      Finger server routines.  Written by Michael T. Horne - KA7AXD.
  6.  *      Copyright 1988 by Michael T. Horne, All Rights Reserved.
  7.  *      Permission granted for non-commercial use and copying, provided
  8.  *      that this notice is retained.
  9.  *
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include "global.h"
  16. #include "mbuf.h"
  17. #include "timer.h"
  18. #include "internet.h"
  19. #include "icmp.h"
  20. #include "netuser.h"
  21. #include "tcp.h"
  22. #include "finger.h"
  23. #include "session.h"
  24. #include "misc.h"
  25. #include "arc.h"
  26.  
  27. static void sndmsg(struct tcb *, char *);
  28.  
  29. struct tcb *fing_tcb = NULLTCB;
  30. int16 finger_notify = 1;
  31.  
  32. int finger1(int argc, char **argv)
  33. {
  34.         extern int32    ip_addr;
  35.         struct socket   lsocket;
  36.  
  37.         if (fing_tcb)
  38.                 return(0);
  39.         /* start finger daemon */
  40.         lsocket.address = ip_addr;
  41.         if(argc < 2)
  42.                 lsocket.port = FINGER_PORT;
  43.         else
  44.                 lsocket.port = atoi(argv[1]);
  45.         fing_tcb = open_tcp(&lsocket, NULLSOCK, TCP_SERVER, 0, (void(*)())rcv_fing,
  46.                 NULLVFP, (void(*)())fing_state, 0, NULL);
  47.         return(0);
  48. }
  49. /*
  50.  *      Handle incoming finger connections and closures.
  51.  * 
  52.  */
  53. void fing_state(struct tcb *tcb, char old, char new)
  54. {
  55.         struct finger *fing;
  56.  
  57.         old = old;
  58.  
  59.         switch(new){
  60.         case ESTABLISHED:
  61.                 log_event(tcb,"open Finger");
  62.                 fing = (struct finger *) malloc(sizeof(struct finger));
  63.  
  64.                 tcb->user = (char *)fing;       /* Upward pointer */
  65.                 fing->tcb = tcb;                /* Downward pointer */
  66.                 if (finger_notify)  {
  67.                         cwprintf(NULL, "You're being fingered by %s!\r\n",
  68.                                 psocket(&tcb->conn.remote));
  69.                 }
  70.                 return;
  71.         case CLOSED:
  72.                 if (tcb == fing_tcb)
  73.                         fing_tcb = NULLTCB;
  74.                 if (tcb->user != NULLCHAR)
  75.                         free(tcb->user);
  76.                 del_tcp(tcb);
  77.                 break;
  78.         }
  79. }
  80.  
  81. /*
  82.  *      Stop the finger server.
  83.  */
  84.  
  85. int finger0(void)
  86. {
  87.         if (fing_tcb != NULLTCB) {
  88.                 close_tcp(fing_tcb);
  89.                 fing_tcb = NULLTCB;
  90.         }
  91.         return(0);
  92. }
  93.  
  94. /*
  95.  *      Send a short message on a tcb
  96.  */
  97.  
  98. static void sndmsg(struct tcb *tcb, char *msg)
  99. {
  100.         struct mbuf *bp;
  101.  
  102.         bp = qdata(msg,(int16)strlen(msg));
  103.         send_tcp(tcb,bp);
  104. }
  105.  
  106. /*
  107.  *      Finger receive upcall.  This is the guts of the finger server.
  108.  *      The user to finger is read from the socket.  If only a newline
  109.  *      is read, then send the remote host a list of all known 'users' on
  110.  *      this system.
  111.  */
  112.  
  113. void rcv_fing(register struct tcb *tcb, int16 ccnt)
  114. {
  115.         struct finger   *fing;
  116.         FILE            *fuser;
  117.         struct mbuf     *mbuf,
  118.                         *bp;
  119.         char            *buf,
  120.                         *who,
  121.                         *finger_file,
  122.                         *path,
  123.                         ch,
  124.                         temp[80],
  125.                         user[80];
  126.         int             cnt;
  127.         int             size;
  128.  
  129.         ccnt = ccnt;
  130.  
  131.         if ((fing = (struct finger *) tcb->user) == NULLFING)   /* uh oh! */
  132.                 return;
  133.         if(recv_tcp(tcb,&bp,FINGNAMELEN) == 0)
  134.                 return;
  135.         if ((who = malloc(FINGNAMELEN + 1)) == NULL) {
  136.                 free_p(bp);
  137.                 return;
  138.         }
  139.  
  140.         cnt = pullup(&bp, who, FINGNAMELEN);    /* get 'user' name */
  141.         who[cnt] = '\0';                        /* NULL terminate it */
  142.         free_p(bp);                             /* all done with bp */
  143.  
  144.         if (*who == '\015' || *who == '\012') { /* give him a user listing */
  145.                 int found = 0;
  146.  
  147.                 path = (char *) malloc(strlen(fingerpath) + 5);
  148.                 /* create wildcard path to finger files */
  149.                 strcpy(path, fingerpath);
  150.  
  151.                 sndmsg(tcb, "Known users on this system:\015\012");
  152.                 for (filedir(path, 0, user); user[0] != '\0';
  153.                         filedir (path, 1, user))  {
  154.                         found++;
  155.                         sprintf(temp, "        %s\015\012", user);
  156.                         sndmsg(tcb, temp);
  157.                 }
  158.                 if (!found)
  159.                         sndmsg(tcb, "None!\015\012");
  160.  
  161.                 free(path);
  162.         }
  163.         else {
  164.                 buf = who;
  165.                 while (*buf != '\015' && *buf != '\012' && *buf != '\0')
  166.                         buf++;
  167.                 *buf = '\0';
  168.                 /*
  169.                  *      Create path to user's finger file and see if the
  170.                  *      the file exists.
  171.                  */
  172.                 finger_file = malloc(strlen(fingerpath) + strlen(who) + 5);
  173.                 if (finger_file == NULL) {      /* uh oh... */
  174.                         free(who);              /* clean up */
  175.                         close_tcp(tcb);         /* close socket */
  176.                         return;
  177.                 }
  178.                 sprintf(finger_file, "%s.%s", fingerpath, who);
  179.  
  180.                 if ((fuser = fopen(finger_file, "r")) == (FILE *) NULL) {
  181.                         sprintf(temp, "User %s not known\015\012", who);
  182.                         sndmsg(tcb, temp);
  183.                 }
  184.                 else {                          /* valid 'user' */
  185.                         ch = fgetc(fuser);      /* first get must be outside */
  186.                         while (!feof(fuser)) {
  187.                                 size = tcb->window;
  188.                                 if ((mbuf = alloc_mbuf(size)) == NULLBUF) {
  189.                                         fclose(fuser);  /* barf */
  190.                                         free(who);
  191.                                         free(finger_file);
  192.                                         return;
  193.                                 }
  194.                                 buf = mbuf->data;  /* pointer to buffer */
  195.                                 while(!feof(fuser) && size--) { /* loop */
  196.                                         switch(ch) {
  197.                                             case '\032':    /* NO ^Z's! */
  198.                                                     break;
  199.                                             case '\012':    /* EOL */
  200.                                                     *buf++ = '\015';
  201.                                                     *buf++ = '\012';
  202.                                                     mbuf->cnt += 2;
  203.                                                     break;
  204.                                             case '\015':
  205.                                                     break;
  206.                                             default:
  207.                                                     *buf++ = ch;
  208.                                                     mbuf->cnt++;
  209.                                                     break;
  210.                                         }
  211.                                         ch = fgetc(fuser);
  212.                                 }
  213.                                 send_tcp(tcb, mbuf);    /* send info */
  214.                         }
  215.                         fclose(fuser);
  216.                 }
  217.                 free(finger_file);
  218.         }
  219.         free(who);
  220.         close_tcp(tcb);                 /* close socket */
  221.         return;
  222. }
  223.  
  224.